module klang.klang.转换工厂.中间码转换.实例化泛型.实例化泛型_;
import 全局;
import ··Klang节点_ = klang.klang.语法节点.Klang节点_;
import klang.编译.类型.类型_: 基工厂_ = 节点工厂_, 基础符号_ = 符号_, 转换上下文_, 转换函数_, 输出解析器_, 转换支持_, 程序主机接口_, 打印助手_, EmitHint, IEmitTextWriter, 打印机_;
import klang.编译.输出节点.输出节点_: EmitFlags, addEmitFlags, getOriginalNode_1;
import klang.编译.语法节点.节点_: 基础节点_ = 节点_, 基础源文件_ = 源文件_, 节点数组_;
import klang.klang.语法节点.Klang节点_: 节点_ = Klang节点_, 源文件_ = Klang源文件_, 标识符_ = Klang标识符_, 语句_, 版本语句_, 表达式_, 块_, 测试单元语句_, 断言语句_, 变量声明_, 导入从版本成员_, 导入版本成员_, 导入成员块_, 导入从成员块_, 导入从成员_, 导入成员_, 程序声明_, 函数声明_, 形参声明_, 对象声明_, 方法声明_, 构建声明_, 释放声明_, 属性赋值_, 如果语句_, 返回语句_, 抛出语句_, 属性声明_, 继承子句_, 结构声明节点_ = 结构声明_, 调用表达式_, 类型断言表达式_, 符号引用表达式_, 前缀一元表达式_, 二元表达式_, 类型形参_, 获取源文件;
import klang.klang.检查.klang检查_: Klang转换支持_, combineTypeMappers, createTypeMapper, instantiateType, instantiateTypes, 获取节点Id, 获取符号Id, 获取类型Id, 获取签名Id, 获取字面量类型的基约束类型, 获取父符号, 创建泛型引用, getTypeArguments, 获取签名从签名声明, getReturnTypeOfSignature, 获取类型节点的类型, 计算类型断言表达式, 获取源文件的程序声明, 获取符号的声明类型;
import klang.klang.类型.klang类型_: 符号_ = Klang符号_, 类型_ = Klang类型_, 签名_ = Klang签名_, KSK, 编译选项_, 节点标志_, 节点扩展_, 类型映射_, 类型标志_, Klang输出种类_, Klang打印选项_, 符号标志_, 复合标志_, klang解析的模块名称_;
import klang.编译.核心.核心_: 词典_, 整数_, 创建数组, 创建词典, 返回零值, 映射, 循环每个, 最小, 获取正规文件名函数_, 查找索引, 结尾包含, 文本包含, 按字符分割, 部分, 连接;
import klang.编译.节点访问.访问节点_: Visitor, visitNode, visitNodes;
import klang.编译.路径.路径_: 获取正规化路径组件组, 获取目录路径;
import klang.klang.节点访问.Klang节点访问_: visitEachChild;
import klang.klang.节点工厂.Klang工厂_: 节点工厂标志_, 节点工厂_ = Klang节点工厂_;
import klang.klang.转换工厂.转换工具.Klang转换工具_: 获取输出文件名;
import klang.编译.输出工具.输出工具_: 创建文本写;
import klang.klang.打印输出.Klang打印输出_: 创建打印机 = klang创建打印机;
import klang.编译.工具.工具_: getParseTreeNode_1, 创建符号表;
import klang.klang.转换工厂.中间码转换.类型.中间码类型_: 未整合源文件_, 未整合的泛型源文件_, 实例化内容_, 实例化种类_, 外部引用类实例化内容_, 类实例化内容_;
import klang.klang.转换工厂.中间码转换.工具.工具_: 获取符号文本Id, 获取类型文本Id, 获取声明节点的符号, 实例化类型;
import klang.klang.转换工厂.中间码转换.中间码_: 实例化基类, 全局的实例化类型引用;
Klang转换支持_ klang检查;
未整合的泛型源文件_ 未整合的泛型文件;
未整合源文件_ 当前未整合的源文件;
long 当前源码Id;
类型_ 当前类型;
实例化内容_ 当前结果;
类型映射_ 当前映射;
节点_[] 当前类型成员;
节点_[] 当前初始成员;
节点_[] 当前虚表成员;
节点工厂_ fc;
void 初始环境(Klang转换支持_ 检查, 未整合的泛型源文件_ 文件, 节点工厂_ 工厂) {
    .当前源码Id = -1;
    .klang检查 = 检查;
    .未整合的泛型文件 = 文件;
    .fc = 工厂;
}
实例化内容_ 实例化泛型基类(类型_ Bt) {
    if (.类型已经实例化(Bt)) {
        return .获取类型的实例化(Bt);
    }
    类型_ 储存的当前类型 = .当前类型;
    .当前类型 = Bt;
    基础符号_ 符号 = Bt.符号;
    基础节点_ 基类声明 = 符号.值声明;
    程序声明_ 基类的程序集 = (cast(程序声明_)(基类声明.父节点));
    符号_ 程序符号 = klang检查.获取合并符号(基类的程序集.符号);
    dstring ID = 获取符号文本Id(程序符号);
    if (!未整合的泛型文件.未整合的源文件集合.具有(ID)) {
        未整合的泛型文件.未整合的源文件集合.p·设置(ID, new 未整合源文件_());
    }
    源文件_ 基类的源文件 = 获取源文件(基类的程序集.父节点);
    未整合源文件_ 储存当前未整合的源文件 = .当前未整合的源文件;
    .当前未整合的源文件 = 未整合的泛型文件.未整合的源文件集合.获取(ID);
    long 储存当前源码Id = .当前源码Id;
    if (当前未整合的源文件.源文件组内索引.具有(基类的源文件.文件名)) {
        .当前源码Id = 当前未整合的源文件.源文件组内索引.获取(基类的源文件.文件名);
    }
    else {
        .当前源码Id = 当前未整合的源文件.整合的文件.length;
        当前未整合的源文件.源文件组内索引.p·设置(基类的源文件.文件名, .当前源码Id);
        .追加!(源文件_)(当前未整合的源文件.整合的文件, 基类的源文件);
    }
    .实例化访问(基类声明);
    实例化内容_ 结果 = .获取类型的实例化(Bt);
    .当前类型 = 储存的当前类型;
    .当前未整合的源文件 = 储存当前未整合的源文件;
    .当前源码Id = 储存当前源码Id;
    return 结果;
}
void 实例化访问(基础节点_ n) {
    switch (n.目标种类) {
        case KSK.对象声明: {
            return .访问对象声明((cast(对象声明_)(n)));
        }
        default: break;
    }
}
// 泛型对象声明;
void 访问对象声明(对象声明_ n) {
    节点_[] 储存当前虚表成员 = .当前虚表成员;
    符号_ 符号 = 获取声明节点的符号(n);
    类型_ 声明类型 = 获取符号的声明类型(符号);
    类型_ 基类型 = 声明类型.解析的基类;
    类型_[] 形参组 = 声明类型.类型形参;
    类型_[] 实参组 = 当前类型.类型实参;
    类型映射_ 储存当前映射 = cast(类型映射_)(.当前映射);
    .当前映射 = createTypeMapper(形参组, 实参组);
    基类型 = instantiateType(基类型, cast(类型映射_)(.当前映射));
    实例化内容_ 实例化基类内容 = 实例化基类(基类型);
    .当前映射 = cast(类型映射_)(储存当前映射);
    实例化内容_ 储存当前结果 = .当前结果;
    节点_[] 储存当前类型成员 = .当前类型成员;
    节点_[] 储存当前初始成员 = .当前初始成员;
    .当前初始成员 = 创建数组!(节点_)();
    .当前类型成员 = 创建数组!(节点_)();
    .当前虚表成员 = 创建数组!(节点_)();
    .当前结果 = new 类实例化内容_();
    if ((基类型.复合标志 & 复合标志_.泛型引用_) != 0) {
    }
    else {
    }
    foreach (节点_ nz; n.成员组) {
        .访问对象声明成员(nz);
    }
    .当前结果 = 储存当前结果;
    .当前类型成员 = 储存当前类型成员;
    .当前初始成员 = 储存当前初始成员;
    .当前虚表成员 = 储存当前虚表成员;
}
bool 类型已经实例化(类型_ T) {
    dstring id = 获取类型文本Id(T);
    return 全局的实例化类型引用.具有(id);
}
实例化内容_ 获取类型的实例化(类型_ T) {
    dstring id = 获取类型文本Id(T);
    return 全局的实例化类型引用.获取(id);
}
基础节点_ 访问对象声明成员(基础节点_ n) {
    switch (n.目标种类) {
        case KSK.属性声明: {
            return .访问属性声明((cast(属性声明_)(n)));
        }
        case KSK.构建声明: {
            return .访问构建声明((cast(构建声明_)(n)));
        }
        case KSK.方法声明: {
            return .访问方法声明((cast(方法声明_)(n)));
        }
        case KSK.释放声明: {
            return .访问释放声明((cast(释放声明_)(n)));
        }
        default: break;
    }
    return ··null!(基础节点_);
}
基础节点_ 访问属性声明(属性声明_ n) {
    if ((n.符号.标志 & 符号标志_.重载_) != 0) {
    }
    else {
        符号_ 符号 = (cast(符号_)(n.符号));
        类型_ 属性类型 = klang检查.获取符号的类型(符号);
        类型_ 实例化属性类型 = instantiateType(属性类型, cast(类型映射_)(.当前映射));
        属性声明_ 新属性 = fc.创建属性声明(n.名称, 实例化类型(实例化属性类型));
        新属性.符号 = n.符号;
        (cast(符号_)(新属性.符号)).类型 = 实例化属性类型;
        .追加!(节点_)(.当前类型成员, 新属性);
        属性赋值_ 属性赋值 = fc.创建属性赋值(n.名称, .访问常量表达式(n.初始化));
        .追加!(节点_)(.当前初始成员, 属性赋值);
    }
    return ··null!(基础节点_);
}
节点_ 访问常量表达式(节点_ n = ··null!(节点_)) {
    if (n is ··null!(节点_)) {
        return (cast(节点_)(fc.转为令牌(KSK.零值_)));
    }
    return n;
}
基础节点_ 访问构建声明(构建声明_ n) {
    return ··null!(基础节点_);
}
基础节点_ 访问方法声明(方法声明_ n) {
    if ((n.类型形参 is null) || (n.类型形参.原型 is ··null!(类型形参_[])) || n.类型形参.length == 0) {
    }
    return ··null!(基础节点_);
}
基础节点_ 访问释放声明(释放声明_ n) {
    return ··null!(基础节点_);
}
